#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
模块名称: document_management_api.py
完整存储路径: backend/api/admin/document_management_api.py
功能说明:
    文档管理API接口，支持隐私政策、用户协议、公告等文档的CRUD操作
    包括版本管理、审核流程、发布控制等功能
    
路由说明:
    - GET /api/admin/documents - 获取文档列表
    - POST /api/admin/documents - 创建新文档
    - GET /api/admin/documents/<id> - 获取文档详情
    - PUT /api/admin/documents/<id> - 更新文档
    - DELETE /api/admin/documents/<id> - 删除文档
    - POST /api/admin/documents/<id>/publish - 发布文档
    - POST /api/admin/documents/<id>/archive - 归档文档
"""

from flask import Blueprint, request, jsonify
from flask_jwt_extended import jwt_required, get_jwt_identity
from functools import wraps
from datetime import datetime
from backend.models.document import Document, DocumentType, DocumentStatus, UserDocumentAgreement
from backend.models.user import User
from backend.infrastructure.database import db
from backend.services.unified_log_service import log_service
from sqlalchemy import and_, or_

document_management_api = Blueprint('document_management_api', __name__)

# 管理员权限装饰器
def admin_required(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        from flask_jwt_extended import get_jwt
        claims = get_jwt()
        roles = claims.get('roles', [])
        if 'admin' not in roles:
            return jsonify({'success': False, 'message': '仅管理员可操作'}), 403
        return fn(*args, **kwargs)
    return wrapper

@document_management_api.route('/api/admin/documents', methods=['GET'])
@jwt_required()
@admin_required
def list_documents():
    """获取文档列表"""
    try:
        # 获取查询参数
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 20, type=int)
        doc_type = request.args.get('type')
        status = request.args.get('status')
        search_term = request.args.get('search', '').strip()
        
        # 构建查询
        query = Document.query
        
        # 类型筛选
        if doc_type:
            query = query.filter(Document.document_type == DocumentType(doc_type))
        
        # 状态筛选
        if status:
            query = query.filter(Document.status == DocumentStatus(status))
        
        # 搜索功能
        if search_term:
            query = query.filter(
                or_(
                    Document.title.like(f'%{search_term}%'),
                    Document.content.like(f'%{search_term}%')
                )
            )
        
        # 分页查询
        pagination = query.order_by(Document.created_at.desc()).paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        documents = [doc.to_dict() for doc in pagination.items]
        
        return jsonify({
            'success': True,
            'data': {
                'documents': documents,
                'pagination': {
                    'page': page,
                    'per_page': per_page,
                    'total': pagination.total,
                    'pages': pagination.pages,
                    'has_next': pagination.has_next,
                    'has_prev': pagination.has_prev
                }
            }
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'获取文档列表失败: {str(e)}'
        }), 500

@document_management_api.route('/api/admin/documents', methods=['POST'])
@jwt_required()
@admin_required
def create_document():
    """创建新文档"""
    try:
        data = request.get_json()
        current_user_id = get_jwt_identity()
        
        # 验证必填字段
        required_fields = ['title', 'document_type', 'content']
        for field in required_fields:
            if not data.get(field):
                return jsonify({
                    'success': False,
                    'message': f'缺少必填字段: {field}'
                }), 400
        
        # 验证文档类型
        try:
            doc_type = DocumentType(data['document_type'])
        except ValueError:
            return jsonify({
                'success': False,
                'message': '无效的文档类型'
            }), 400
        
        # 创建文档
        document = Document(
            title=data['title'],
            document_type=doc_type,
            content=data['content'],
            version=data.get('version', '1.0'),
            effective_date=datetime.fromisoformat(data['effective_date']) if data.get('effective_date') else None,
            expiry_date=datetime.fromisoformat(data['expiry_date']) if data.get('expiry_date') else None,
            is_mandatory=data.get('is_mandatory', False),
            created_by=current_user_id,
            status=DocumentStatus.DRAFT
        )
        
        db.session.add(document)
        db.session.commit()
        
        # 记录操作日志
        log_service.log_operation(
            user_id=current_user_id,
            action='CREATE',
            table_name='documents',
            record_id=document.id,
            details=f'创建文档: {document.title}'
        )
        
        return jsonify({
            'success': True,
            'data': document.to_dict(),
            'message': '文档创建成功'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'创建文档失败: {str(e)}'
        }), 500

@document_management_api.route('/api/admin/documents/<int:doc_id>', methods=['GET'])
@jwt_required()
@admin_required
def get_document(doc_id):
    """获取文档详情"""
    try:
        document = Document.query.get_or_404(doc_id)
        return jsonify({
            'success': True,
            'data': document.to_dict()
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'获取文档详情失败: {str(e)}'
        }), 500

@document_management_api.route('/api/admin/documents/<int:doc_id>', methods=['PUT'])
@jwt_required()
@admin_required
def update_document(doc_id):
    """更新文档"""
    try:
        document = Document.query.get_or_404(doc_id)
        data = request.get_json()
        current_user_id = get_jwt_identity()
        
        # 检查文档状态，已发布的文档需要创建新版本
        if document.status == DocumentStatus.PUBLISHED:
            return jsonify({
                'success': False,
                'message': '已发布的文档不能直接修改，请创建新版本'
            }), 400
        
        # 更新字段
        if 'title' in data:
            document.title = data['title']
        if 'content' in data:
            document.content = data['content']
        if 'version' in data:
            document.version = data['version']
        if 'effective_date' in data:
            document.effective_date = datetime.fromisoformat(data['effective_date']) if data['effective_date'] else None
        if 'expiry_date' in data:
            document.expiry_date = datetime.fromisoformat(data['expiry_date']) if data['expiry_date'] else None
        if 'is_mandatory' in data:
            document.is_mandatory = data['is_mandatory']
        
        document.updated_at = datetime.utcnow()
        
        db.session.commit()
        
        # 记录操作日志
        log_service.log_operation(
            user_id=current_user_id,
            action='UPDATE',
            table_name='documents',
            record_id=document.id,
            details=f'更新文档: {document.title}'
        )
        
        return jsonify({
            'success': True,
            'data': document.to_dict(),
            'message': '文档更新成功'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'更新文档失败: {str(e)}'
        }), 500

@document_management_api.route('/api/admin/documents/<int:doc_id>/publish', methods=['POST'])
@jwt_required()
@admin_required
def publish_document(doc_id):
    """发布文档"""
    try:
        document = Document.query.get_or_404(doc_id)
        current_user_id = get_jwt_identity()
        
        # 检查文档状态
        if document.status == DocumentStatus.PUBLISHED:
            return jsonify({
                'success': False,
                'message': '文档已经发布'
            }), 400
        
        # 如果是强制性文档（隐私政策、用户协议），先归档同类型的已发布文档
        if document.is_mandatory:
            existing_docs = Document.query.filter(
                and_(
                    Document.document_type == document.document_type,
                    Document.status == DocumentStatus.PUBLISHED
                )
            ).all()
            
            for existing_doc in existing_docs:
                existing_doc.status = DocumentStatus.ARCHIVED
        
        # 更新文档状态
        document.status = DocumentStatus.PUBLISHED
        document.published_at = datetime.utcnow()
        document.reviewed_by = current_user_id
        
        # 如果没有设置生效时间，设置为当前时间
        if not document.effective_date:
            document.effective_date = datetime.utcnow()
        
        db.session.commit()
        
        # 记录操作日志
        log_service.log_operation(
            user_id=current_user_id,
            action='PUBLISH',
            table_name='documents',
            record_id=document.id,
            details=f'发布文档: {document.title}'
        )
        
        return jsonify({
            'success': True,
            'data': document.to_dict(),
            'message': '文档发布成功'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'发布文档失败: {str(e)}'
        }), 500

@document_management_api.route('/api/admin/documents/<int:doc_id>/archive', methods=['POST'])
@jwt_required()
@admin_required
def archive_document(doc_id):
    """归档文档"""
    try:
        document = Document.query.get_or_404(doc_id)
        current_user_id = get_jwt_identity()
        
        # 更新文档状态
        document.status = DocumentStatus.ARCHIVED
        document.updated_at = datetime.utcnow()
        
        db.session.commit()
        
        # 记录操作日志
        log_service.log_operation(
            user_id=current_user_id,
            action='ARCHIVE',
            table_name='documents',
            record_id=document.id,
            details=f'归档文档: {document.title}'
        )
        
        return jsonify({
            'success': True,
            'data': document.to_dict(),
            'message': '文档归档成功'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'归档文档失败: {str(e)}'
        }), 500

@document_management_api.route('/api/admin/documents/<int:doc_id>/agreements', methods=['GET'])
@jwt_required()
@admin_required
def get_document_agreements(doc_id):
    """获取文档确认记录"""
    try:
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 20, type=int)
        
        query = UserDocumentAgreement.query.filter_by(document_id=doc_id)
        
        pagination = query.order_by(UserDocumentAgreement.agreed_at.desc()).paginate(
            page=page, per_page=per_page, error_out=False
        )
        
        agreements = [agreement.to_dict() for agreement in pagination.items]
        
        return jsonify({
            'success': True,
            'data': {
                'agreements': agreements,
                'pagination': {
                    'page': page,
                    'per_page': per_page,
                    'total': pagination.total,
                    'pages': pagination.pages,
                    'has_next': pagination.has_next,
                    'has_prev': pagination.has_prev
                }
            }
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'获取确认记录失败: {str(e)}'
        }), 500

@document_management_api.route('/api/admin/documents/stats', methods=['GET'])
@jwt_required()
@admin_required
def get_document_stats():
    """获取文档统计信息"""
    try:
        # 按状态统计
        draft_count = Document.query.filter_by(status='draft').count()
        published_count = Document.query.filter_by(status='published').count()
        archived_count = Document.query.filter_by(status='archived').count()
        
        # 按类型统计
        policy_count = Document.query.filter_by(document_type='policy').count()
        manual_count = Document.query.filter_by(document_type='manual').count()
        template_count = Document.query.filter_by(document_type='template').count()
        other_count = Document.query.filter_by(document_type='other').count()
        
        # 今日新增
        from datetime import date
        today = date.today()
        today_count = Document.query.filter(
            db.func.date(Document.created_at) == today
        ).count()
        
        return jsonify({
            'success': True,
            'data': {
                'draft': draft_count,
                'published': published_count,
                'archived': archived_count,
                'policy': policy_count,
                'manual': manual_count,
                'template': template_count,
                'other': other_count,
                'today': today_count,
                'total': draft_count + published_count + archived_count
            }
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'获取统计信息失败: {str(e)}'
        }), 500

# 初始化默认文档的函数
def init_default_documents():
    """初始化默认的隐私政策和用户协议文档"""
    # 检查是否已存在默认文档
    privacy_policy = Document.query.filter_by(
        document_type=DocumentType.PRIVACY_POLICY,
        status=DocumentStatus.PUBLISHED
    ).first()
    
    user_agreement = Document.query.filter_by(
        document_type=DocumentType.USER_AGREEMENT,
        status=DocumentStatus.PUBLISHED
    ).first()
    
    # 获取系统管理员用户
    admin_user = User.query.filter_by(role='admin').first()
    if not admin_user:
        print("警告: 未找到管理员用户，无法创建默认文档")
        return
    
    # 创建默认隐私政策
    if not privacy_policy:
        privacy_content = """# 隐私政策

## 1. 信息收集

我们收集的信息类型包括：
- 您主动提供的信息（如注册信息、联系方式）
- 自动收集的信息（如设备信息、日志信息）
- 第三方提供的信息

## 2. 信息使用

我们使用收集的信息来：
- 提供、维护和改进我们的服务
- 与您沟通
- 保护我们的服务和用户

## 3. 信息分享

我们不会向第三方出售、交易或转让您的个人信息，除非：
- 获得您的明确同意
- 法律要求
- 保护我们的权利和安全

## 4. 数据安全

我们采用适当的技术和组织措施来保护您的个人信息。

## 5. 您的权利

您有权：
- 访问和更正您的个人信息
- 删除您的个人信息
- 限制或反对处理
- 数据可携带性

## 6. 联系我们

如有任何问题，请联系我们：
- 邮箱：privacy@devvision.com
- 电话：400-123-4567

最后更新：2025年8月28日"""

        privacy_doc = Document(
            title="隐私政策",
            document_type=DocumentType.PRIVACY_POLICY,
            content=privacy_content,
            version="1.0",
            status=DocumentStatus.PUBLISHED,
            is_mandatory=True,
            created_by=admin_user.id,
            reviewed_by=admin_user.id,
            published_at=datetime.utcnow(),
            effective_date=datetime.utcnow()
        )
        db.session.add(privacy_doc)
    
    # 创建默认用户协议
    if not user_agreement:
        agreement_content = """# 用户协议

## 1. 服务条款

欢迎使用DEV_VISION系统。使用我们的服务即表示您同意本协议。

## 2. 账户责任

您有责任：
- 保护账户安全
- 提供准确信息
- 遵守使用规则

## 3. 服务使用

您可以：
- 查询学生视力数据
- 记录干预操作
- 参与社交分享

您不可以：
- 恶意使用服务
- 侵犯他人权益
- 传播不当内容

## 4. 知识产权

本服务包含的所有内容均受知识产权法保护。

## 5. 服务变更

我们保留修改或终止服务的权利，并将提前通知用户。

## 6. 争议解决

因本协议产生的争议，双方应友好协商解决。

## 7. 其他条款

本协议的解释和执行适用中华人民共和国法律。

## 8. 联系我们

如有任何问题，请联系我们：
- 邮箱：support@devvision.com
- 电话：400-123-4567

最后更新：2025年8月28日"""

        agreement_doc = Document(
            title="用户协议",
            document_type=DocumentType.USER_AGREEMENT,
            content=agreement_content,
            version="1.0",
            status=DocumentStatus.PUBLISHED,
            is_mandatory=True,
            created_by=admin_user.id,
            reviewed_by=admin_user.id,
            published_at=datetime.utcnow(),
            effective_date=datetime.utcnow()
        )
        db.session.add(agreement_doc)
    
    try:
        db.session.commit()
        print("默认文档创建成功")
    except Exception as e:
        db.session.rollback()
        print(f"创建默认文档失败: {e}")

@document_management_api.route('/api/admin/documents/<int:doc_id>', methods=['DELETE'])
@jwt_required()
@admin_required
def delete_document(doc_id):
    """删除文档"""
    try:
        document = Document.query.get_or_404(doc_id)
        current_user_id = get_jwt_identity()
        
        # 检查文档状态，不能删除已发布的文档
        if document.status == DocumentStatus.PUBLISHED:
            return jsonify({
                'success': False,
                'message': '已发布的文档不能删除，请先归档'
            }), 400
        
        # 记录操作日志
        log_service.log_operation(
            user_id=current_user_id,
            action='DELETE',
            table_name='documents',
            record_id=document.id,
            details=f'删除文档: {document.title}'
        )
        
        db.session.delete(document)
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': '文档删除成功'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'删除文档失败: {str(e)}'
        }), 500
